// 抽象类
// 抽象类: 不能被实例化 --> 不能被 new
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
// 描述一个类的外观
var CaiKuen = /** @class */ (function () {
    function CaiKuen() {
    }
    return CaiKuen;
}());
var Cai = /** @class */ (function (_super) {
    __extends(Cai, _super);
    function Cai() {
        return _super.call(this) || this;
    }
    Cai.prototype.sing = function () {
    };
    Cai.prototype.jump = function () {
    };
    Cai.prototype.rap = function () {
    };
    return Cai;
}(CaiKuen));
new Cai();
// --------------------------------------------------------------------
// 接口
// 对某个类或者函数的外观描述
// 插座
/*
    插座:必须要有三个空
        1. 正极
        2. 负级
        3. 地线
*/
// 接口继承
/**
interface Person{
    name: string
    age: number
}
interface Shape {
    color: string;
}
interface CaiKuen extends Person, Shape{
    readonly hairColor: string
    // 背带裤
    trousers: string
    // 皮鞋
    shoes?: string,
}

let cai = <CaiKuen>{
    hairColor: 'color',
    trousers: '背带裤',
    color: 'color'
}

console.log(
    cai
) */
// 接口约束 json
/*interface CaiKuen {
    // 发色
    // hairColor: string
    readonly hairColor: string
    // 背带裤
    trousers: string
    // 皮鞋
    shoes?: string,
}

let josn = <CaiKuen>{
    hairColor: '黄色',
    trousers: '背带裤',
    // shoes: '皮鞋'
}
josn.hairColor = '绿色'
*/
// 可索引的类型
/*interface CaiKuen{
    [index: number]: string
}

let json: CaiKuen = {
    0: '1',
    1: '2',
    3: '2',
}

let arr: Array<CaiKuen> = ['1', '2', '3'] */
// 接口约束类
// 蔡徐坤
/**interface CaiKuen {
    // 唱
    sing(): void
    // 跳
    jump(): void
    // rap
    rap(): void

    // 属性
    // 发色
    hairColor: string
    // 背带裤
    trousers: string
    // 皮鞋
    shoes: string
}

// 类实现接口
class Cai implements CaiKuen {

    public hairColor:string
    public trousers:string
    public shoes:string

    sing():void {

    }
    jump():void {

    }
    rap():void {

    }
} */
// 接口约束函数
/**interface Socket{
    (positive: number, negative: number, ground: number): void
}

const mi:Socket = (
    positive: number,
    negative: number,
    ground: number
    ):void => {
    console.log(positive, negative, ground)
}

mi(1,2,3) */
// --------------------------------------------------------------------
// 类
// 访问修饰符
// private  只有类的内部可以访问
// protected    只有类和子类才可以访问到
// public   任何地方都能访问
// static   静态熟悉或方法, 在类声明之前定义好
// 按照访问范围排序
// private < protected < public < static
// 私有变量封装
// 1. 定义私有变量
// 2. 定义存取器来设置私有变量的存取函数
/**
class user {
    public name: string
    constructor(name: string) {
        this.name = name
    }
    protected eat():void {
        console.log(
            `${this.name}: 吃饱了`
        )
    }
}


class Person extends user {
    // this
    private _age: number
    static gender: number = 0

    constructor(name:string, age:number) {
        super(name)
        this._age = age
    }
    get age() {
        console.log('获取年龄')
        return this._age
    }
    set age(v:number) {
        console.log('设置年龄')
        if (v > 0 && v < 120) {
            this._age = v
        } else {
            throw new Error('年龄不合法')
        }
    }

    public sleep() {
        // 吃饱了
        super.eat();
        // 睡觉
        console.log(
            `${this.name}: 睡觉`
        )
    }
}
let p: Person = new Person('石兴龙', 18);

// Person.gender = 1
p.sleep()
p.age = 130

console.log(
    p.age
) */
// console.log(
//     p.name,
//     Person.gender
// )
// --------------------------------------------------------------------
// 枚举
// 描述同一件事物
// old
// const PADDING = 'PADDING'
// const FULFILLED = 'FULFILLED'
// const REJECTED = 'REJECTED'
// // new
// enum Types{PADDING, FULFILLED, REJECTED}
// Types.FULFILLED
// Types.PADDING
// --------------------------------------------------------------------
// 联合类型
// let a:(string|number) = 12
// let a:(string|number)[] = [1,2,3, 'abc'] //数组联合类型
// 类型约束
// let a:number = 1;
// let s = 'abc';
// let a: Boolean = true;
// let a:undefined = undefined
// let arr: number[] = [1,2,3, 'string']
// let arr: Array<number|string| boolean> = [1,2,3, 'string', true]
// let arr: Array<any> = [1,2,3, 'string', true, {}, new Date]
// let json: {name: string, age: number} = {name: 'sxl', age: 18}
// 函数
// old
/**const sum = (a, b) => {
    if(typeof a === 'number' && typeof b === 'number') {
        return a + b
    }
    throw new Error('参数类型错误')
} */
/**const sum = (a:number, b:number) => {
    return a + b
} */
// 返回值类型
/**const sum = (a:number, b:number):number => {
    return a + b
}
// 没有返回值时, 类型为 void
const sayHi = (): void => {
    console.log('hello world')
}
 */
